/**
 * 雨量计算服务模块
 * 提供各类雨量计算相关的业务逻辑处理
 * 封装雨量算法与IPC调用之间的转换逻辑
 */
import { RainfallAlgorithms } from '../../algorithms/rainfall';

/**
 * 雨量计算服务类
 * 封装雨量相关计算功能，提供统一的服务接口
 * 处理计算请求并返回格式化的结果
 */
export class RainfallService {
  /**
 * 暴雨指数计算
 * @param params 计算参数
 * @param params.F 汇水面积（平方公里）
 * @returns 包含计算结果的对象 { success: boolean, data?: any, error?: string }
 */
  static async calculateStormIndex(params: any) {
    try {
      const { F } = params;
      const result = RainfallAlgorithms.stormIndex(F);
      return { success: true, data: result };
    } catch (error: any) {
      return { success: false, error: error.message };
    }
  }

  /**
 * 洪峰流量计算
 * @param params 计算参数
 * @param params.K 综合影响系数
 * @param params.H_r 造峰影响雨量
 * @param params.beta 暴雨指数
 * @returns 包含计算结果的对象 { success: boolean, data?: any, error?: string }
 */
  static async calculatePeakFloodFlow(params: any) {
    try {
      const { K, H_r, beta } = params;
      const result = RainfallAlgorithms.peakFloodFlow(K, H_r, beta);
      return { success: true, data: result };
    } catch (error: any) {
      return { success: false, error: error.message };
    }
  }

  /**
 * 造峰影响雨量计算
 * @param params 计算参数
 * @param params.H_Ft 面雨量
 * @param params.T 造峰历时
 * @param params.t 设计历时
 * @param params.d 暴雨参数
 * @param params.n 暴雨递减指数
 * @returns 包含计算结果的对象 { success: boolean, data?: any, error?: string }
 */
  static async calculatePeakRainfallHr(params: any) {
    try {
      const { H_Ft, T, t, d, n } = params;
      const result = RainfallAlgorithms.peakRainfallHr(H_Ft, T, t, d, n);
      return { success: true, data: result };
    } catch (error: any) {
      return { success: false, error: error.message };
    }
  }

  /**
 * 坡降影响系数计算
 * @param params 计算参数
 * @param params.J 河道平均坡降
 * @returns 包含计算结果的对象 { success: boolean, data?: any, error?: string }
 */
  static async calculateSlopeK2(params: any) {
    try {
      const { J } = params;
      const result = RainfallAlgorithms.slopeK2(J);
      return { success: true, data: result };
    } catch (error: any) {
      return { success: false, error: error.message };
    }
  }

  /**
 * 汇水面积影响系数计算
 * @param params 计算参数
 * @param params.F 汇水面积（平方公里）
 * @param params.J 河道平均坡降
 * @returns 包含计算结果的对象 { success: boolean, data?: any, error?: string }
 */
  static async calculateDrainageAreaK1(params: any) {
    try {
      const { F, J } = params;
      const result = RainfallAlgorithms.drainageAreaK1(F, J);
      return { success: true, data: result };
    } catch (error: any) {
      return { success: false, error: error.message };
    }
  }

  /**
 * 设计历时计算
 * @param params 计算参数
 * @param params.F 汇水面积（平方公里）
 * @returns 包含计算结果的对象 { success: boolean, data?: any, error?: string }
 */
  static async calculateDesignDurationT(params: any) {
    try {
      const { F } = params;
      const result = RainfallAlgorithms.designDurationT(F);
      return { success: true, data: result };
    } catch (error: any) {
      return { success: false, error: error.message };
    }
  }

  /**
 * 12小时点暴雨量计算
 * @param params 计算参数
 * @param params.H6 6小时点暴雨量
 * @param params.H24 24小时点暴雨量
 * @returns 包含计算结果的对象 { success: boolean, data?: any, error?: string }
 */
  static async calculatePointRainfall12(params: any) {
    try {
      const { H6, H24 } = params;
      const result = RainfallAlgorithms.pointRainfall12(H6, H24);
      return { success: true, data: result };
    } catch (error: any) {
      return { success: false, error: error.message };
    }
  }

  /**
 * 面雨量计算
 * @param params 计算参数
 * @param params.Ht 点雨量
 * @param params.alpha_t 点面系数
 * @returns 包含计算结果的对象 { success: boolean, data?: any, error?: string }
 */
  static async calculateAreaRainfall(params: any) {
    try {
      const { Ht, alpha_t } = params;
      const result = RainfallAlgorithms.areaRainfall(Ht, alpha_t);
      return { success: true, data: result };
    } catch (error: any) {
      return { success: false, error: error.message };
    }
  }

  /**
 * 24小时点面系数计算
 * @param params 计算参数
 * @param params.F 汇水面积（平方公里）
 * @param params.zone 地区分区
 * @returns 包含计算结果的对象 { success: boolean, data?: any, error?: string }
 */
  static async calculatePointAreaCoefficient24(params: any) {
    try {
      const { F, zone } = params;
      const result = RainfallAlgorithms.pointAreaCoefficient24(F, zone);
      return { success: true, data: result };
    } catch (error: any) {
      return { success: false, error: error.message };
    }
  }

  /**
 * 12小时点面系数计算
 * @param params 计算参数
 * @param params.F 汇水面积（平方公里）
 * @param params.alpha_24 24小时点面系数
 * @returns 包含计算结果的对象 { success: boolean, data?: any, error?: string }
 */
  static async calculatePointAreaCoefficient12(params: any) {
    try {
      const { F, alpha_24 } = params;
      const result = RainfallAlgorithms.pointAreaCoefficient12(F, alpha_24);
      return { success: true, data: result };
    } catch (error: any) {
      return { success: false, error: error.message };
    }
  }

  /**
 * 6小时点面系数计算
 * @param params 计算参数
 * @param params.F 汇水面积（平方公里）
 * @param params.alpha_24 24小时点面系数
 * @returns 包含计算结果的对象 { success: boolean, data?: any, error?: string }
 */
  static async calculatePointAreaCoefficient6(params: any) {
    try {
      const { F, alpha_24 } = params;
      const result = RainfallAlgorithms.pointAreaCoefficient6(F, alpha_24);
      return { success: true, data: result };
    } catch (error: any) {
      return { success: false, error: error.message };
    }
  }

  /**
 * 暴雨参数d选择
 * @param params 计算参数
 * @param params.t 设计历时
 * @returns 包含计算结果的对象 { success: boolean, data?: any, error?: string }
 */
  static async calculateSelectStormParameterD(params: any) {
    try {
      const { t } = params;
      const result = RainfallAlgorithms.selectStormParameterD(t);
      return { success: true, data: result };
    } catch (error: any) {
      return { success: false, error: error.message };
    }
  }

  /**
 * 全雨量计算
 * 合成多个计算步骤，返回详细的中间结果和最终结果
 * @param params 计算参数
 * @param params.k_3 土壤植被影响系数
 * @param params.F 汇水面积（平方公里）
 * @param params.J 河道平均坡降
 * @param params.n 暴雨递减指数
 * @param params.zone 地区分区
 * @param params.H6 6小时点暴雨量
 * @param params.H24 24小时点暴雨量
 * @returns 包含完整计算结果的对象 { success: boolean, data?: any, error?: string }
 * @returns.data 包含各个计算步骤的详细结果，包括造峰历时、暴雨指数、各类系数等
 */
  static async calculateAllRainfall(params: any) {
    try {
      const { k_3, F, J, n, zone, H6, H24 } = params;

      // 计算基础影响系数 k_0
      const k_0 = 0.0298 * Math.pow(F, 0.78);

      // 计算造峰历时 T
      const T = 0.35 * Math.pow(F, 0.52);

      // 计算暴雨指数
      const beta = RainfallAlgorithms.stormIndex(F);

      // 计算汇水面积和坡降影响系数
      const K1 = RainfallAlgorithms.drainageAreaK1(F, J);
      const K2 = RainfallAlgorithms.slopeK2(J);

      // 计算综合影响系数 K
      const K_composite = (k_0 * K1 * K2) / k_3;

      // 计算设计历时
      const t_design = RainfallAlgorithms.designDurationT(F);

      // 计算点面系数
      const alpha_24 = RainfallAlgorithms.pointAreaCoefficient24(F, zone);
      const alpha_12 = RainfallAlgorithms.pointAreaCoefficient12(F, alpha_24);
      const alpha_6 = RainfallAlgorithms.pointAreaCoefficient6(F, alpha_24);

      // 计算12小时点暴雨量
      const H12 = RainfallAlgorithms.pointRainfall12(H6, H24);

      // 计算面雨量（使用12小时点面系数）
      const HFt = RainfallAlgorithms.areaRainfall(H12, alpha_12);

      // 根据设计历时自动选择暴雨参数 d
      const d = RainfallAlgorithms.selectStormParameterD(t_design);

      // 计算造峰影响雨量 H_T
      const H_T = RainfallAlgorithms.peakRainfallHr(HFt, T, t_design, d, n);

      // 计算洪峰流量 Q
      const Q = RainfallAlgorithms.peakFloodFlow(K_composite, H_T, beta);

      const results = {
        '造峰历时': { T },
        '暴雨指数': { F, beta },
        '汇水面积影响系数': { F, J, K1 },
        '坡降影响系数': { J, K2 },
        '综合影响系数': { k_0, k_1: K1, k_2: K2, k_3, K: K_composite },
        '设计历时': { F, t: t_design },
        '点面系数': { F, zone, alpha_24, alpha_12, alpha_6 },
        '12小时点暴雨量': { H6, H24, H12 },
        '面雨量': { Ht: H12, alpha_t: alpha_12, HFt },
        '造峰影响雨量': { H_Ft: HFt, T, t: t_design, d, n, H_T },
        '洪峰流量': { Q, K: K_composite, H_r: H_T, beta, F }
      };

      return { success: true, data: results };
    } catch (error: any) {
      return { success: false, error: error.message };
    }
  }
}